import Vue from 'vue'
import Vuex from 'vuex'
import createPersistedState from "vuex-persistedstate"

Vue.use(Vuex)

// 🔧 工具函数：获取当前页面路径
function getCurrentPagePath() {
	try {
		const pages = getCurrentPages();
		if (pages && pages.length > 0) {
			const currentPage = pages[pages.length - 1];
			const route = currentPage.route;
			const options = currentPage.options;
			
			// 构建完整路径
			let path = `/${route}`;
			if (options && Object.keys(options).length > 0) {
				const params = new URLSearchParams(options).toString();
				path += `?${params}`;
			}
			
			console.log("📍 当前页面路径:", path);
			return path;
		}
	} catch (error) {
		console.error("获取当前页面路径失败:", error);
	}
	return '';
}
 
const store = new Vuex.Store({
 state: {
　　count: 0,
　　// API配置 - 可以根据环境切换
　　isDevelopment: false, // 开发环境标志，后期改为false即可切换到生产环境
　　apiBaseUrl: 'http://192.168.3.37:13788', // 开发环境使用后端IP
　　apiBaseUrlProduction: 'http://wdzbx.zsbike.com.cn:13788', // 生产环境域名
　　// 微信授权专用域名（必须是可信域名）
　　wechatAuthDomain: 'http://cdxt.zsbike.com.cn:8818/#/', // 微信授权回调域名
　　apiVersion: 'api.v2',
　　apiVersionV1: 'api.v1',
　　
　　// 🔐 认证相关状态
　　auth: {
　　　　isAuthenticating: false, // 是否正在认证中
　　　　isAuthenticated: false, // 是否已认证
　　　　isAuthLocked: false, // 防止重复认证的锁
　　　　loadingMessage: '', // 认证过程中的提示信息
　　　　redirectPath: '', // 🎯 授权成功后要跳转的页面路径
　　　　// 🎯 用户基础信息（与后端返回数据结构完全一致）
　　　　userInfo: {
　　　　　　userid: '', // 用户ID
　　　　　　nickname: '', // 昵称
　　　　　　empname: '', // 员工姓名
　　　　　　cardid: '', // 卡号/工号
　　　　　　orgid: '', // 组织ID
　　　　　　orgname: '', // 组织名称
　　　　　　emptype: '', // 岗位类型
　　　　　　sex: '', // 性别
　　　　　　empworkno: '', // 工号
　　　　　　isactive: '', // 是否在职 (1:在职, 0:离职)
　　　　　　startdate: '', // 入职日期
　　　　　　telephone: '' // 电话号码
　　　　},
　　　　employeeInfo: null, // 员工详细信息（UI展示用，包含图标等）
　　　　authError: null, // 认证错误信息
　　　　wxJSSDKReady: false // 企业微信JSSDK是否已准备好
　　}
},
 getters: {
　　// 动态获取当前环境的API地址
　　currentApiBaseUrl: (state) => {
　　　　return state.isDevelopment ? state.apiBaseUrl : state.apiBaseUrlProduction;
　　},
　　// apiBaseUrl 别名，保持向后兼容
　　apiBaseUrl: (state, getters) => {
　　　　return getters.currentApiBaseUrl;
　　},
　　// 获取完整的API地址（包含版本）
　　getApiUrl: (state, getters) => (version = 'v2') => {
　　　　const baseUrl = getters.currentApiBaseUrl;
　　　　const apiVersion = version === 'v1' ? state.apiVersionV1 : state.apiVersion;
　　　　return `${baseUrl}/${apiVersion}`;
　　},
　　
　　// 🔐 认证相关 getters
　　isAuthenticating: (state) => state.auth.isAuthenticating,
　　isAuthenticated: (state) => state.auth.isAuthenticated,
　　isAuthLocked: (state) => state.auth.isAuthLocked,
　　loadingMessage: (state) => state.auth.loadingMessage,
　　userInfo: (state) => state.auth.userInfo,
　　employeeInfo: (state) => state.auth.employeeInfo,
　　authError: (state) => state.auth.authError,
　　wxJSSDKReady: (state) => state.auth.wxJSSDKReady,
　　redirectPath: (state) => state.auth.redirectPath,
　　// 🎯 用户信息相关 getters（直接从userInfo获取）
　　userid: (state) => state.auth.userInfo.userid || '',
　　nickname: (state) => state.auth.userInfo.nickname || '',
　　empname: (state) => state.auth.userInfo.empname || '',
　　cardid: (state) => state.auth.userInfo.cardid || '',
　　orgid: (state) => state.auth.userInfo.orgid || '',
　　orgname: (state) => state.auth.userInfo.orgname || '',
　　emptype: (state) => state.auth.userInfo.emptype || '',
　　sex: (state) => state.auth.userInfo.sex || '',
　　empworkno: (state) => state.auth.userInfo.empworkno || '',
　　isactive: (state) => state.auth.userInfo.isactive || '',
　　startdate: (state) => state.auth.userInfo.startdate || '',
　　telephone: (state) => state.auth.userInfo.telephone || '',
　　// 🔧 便捷getters
　　userName: (state) => state.auth.userInfo.empname || state.auth.userInfo.nickname || '未知用户',
　　isUserActive: (state) => state.auth.userInfo.isactive === '1'
 },
 mutations: {
　　setApiBaseUrl(state, url) {
　　　　state.apiBaseUrl = url
　　},
　　setApiBaseUrlProduction(state, url) {
　　　　state.apiBaseUrlProduction = url
　　},
　　setIsDevelopment(state, isDev) {
　　　　state.isDevelopment = isDev
　　},
　　setApiVersion(state, version) {
　　　　state.apiVersion = version
　　},
　　setApiVersionV1(state, version) {
　　　　state.apiVersionV1 = version
　　},
　　
　　// 🔐 认证相关 mutations
　　SET_AUTH_AUTHENTICATING(state, isAuthenticating) {
　　　　state.auth.isAuthenticating = isAuthenticating;
　　},
　　SET_AUTH_AUTHENTICATED(state, isAuthenticated) {
　　　　state.auth.isAuthenticated = isAuthenticated;
　　},
　　SET_AUTH_LOCKED(state, isLocked) {
　　　　state.auth.isAuthLocked = isLocked;
　　},
　　SET_LOADING_MESSAGE(state, message) {
　　　　state.auth.loadingMessage = message;
　　},
　　SET_USER_INFO(state, userInfo) {
　　　　console.log("🔧 更新用户信息到Vuex state:", userInfo);
　　　　// 🎯 完整保存用户信息，保持与后端返回数据结构一致
　　　　state.auth.userInfo = {
　　　　　　userid: userInfo.userid || '',
　　　　　　nickname: userInfo.nickname || '',
　　　　　　empname: userInfo.empname || '',
　　　　　　cardid: userInfo.cardid || '',
　　　　　　orgid: userInfo.orgid || '',
　　　　　　orgname: userInfo.orgname || '',
　　　　　　emptype: userInfo.emptype || '',
　　　　　　sex: userInfo.sex || '', // 🔧 保存性别信息
　　　　　　empworkno: userInfo.empworkno || '',
　　　　　　isactive: userInfo.isactive || '',
　　　　　　startdate: userInfo.startdate || '',
　　　　　　telephone: userInfo.telephone || ''
　　　　};
　　　　console.log("✅ 用户信息已保存到state.auth.userInfo:", state.auth.userInfo);
　　},
　　SET_EMPLOYEE_INFO(state, employeeInfo) {
　　　　state.auth.employeeInfo = employeeInfo;
　　},
　　SET_AUTH_ERROR(state, error) {
　　　　state.auth.authError = error;
　　},
　　SET_WX_JSSDK_READY(state, ready) {
　　　　state.auth.wxJSSDKReady = ready;
　　},
　　SET_REDIRECT_PATH(state, path) {
　　　　state.auth.redirectPath = path;
　　},
　　CLEAR_AUTH_STATE(state) {
　　　　state.auth.isAuthenticating = false;
　　　　state.auth.isAuthenticated = false;
　　　　state.auth.isAuthLocked = false;
　　　　state.auth.loadingMessage = '';
　　　　// 🔧 重置用户信息为初始结构
　　　　state.auth.userInfo = {
　　　　　　userid: '',
　　　　　　nickname: '',
　　　　　　empname: '',
　　　　　　cardid: '',
　　　　　　orgid: '',
　　　　　　orgname: '',
　　　　　　emptype: '',
　　　　　　sex: '', // 🔧 重置性别字段
　　　　　　empworkno: '',
　　　　　　isactive: '',
　　　　　　startdate: '',
　　　　　　telephone: ''
　　　　};
　　　　state.auth.employeeInfo = null;
　　　　state.auth.authError = null;
　　　　state.auth.wxJSSDKReady = false;
　　　　state.auth.redirectPath = '';
　　}
 },
 actions: {
　　updateApiBaseUrl({ commit }, url) {
　　　　commit('setApiBaseUrl', url)
　　},
　　updateApiBaseUrlProduction({ commit }, url) {
　　　　commit('setApiBaseUrlProduction', url)
　　},
　　switchEnvironment({ commit }, isDev) {
　　　　commit('setIsDevelopment', isDev)
　　},
　　updateApiVersion({ commit }, version) {
　　　　commit('setApiVersion', version)
　　},
　　updateApiVersionV1({ commit }, version) {
　　　　commit('setApiVersionV1', version)
　　},
　　
　　// 🔐 认证相关 actions
　　
　　// 🎯 统一的认证检查（适用于所有页面）
　　checkAuthStatus({ state, commit, dispatch }) {
　　　　console.log("🔍 统一认证检查 - 详细状态:", {
　　　　　　isAuthenticated: state.auth.isAuthenticated,
　　　　　　userid: state.auth.userInfo.userid,
　　　　　　empname: state.auth.userInfo.empname,
　　　　　　userInfoComplete: state.auth.userInfo,
　　　　　　authState: state.auth
　　　　});
　　　　
　　　　// 🎯 详细检查认证条件
　　　　const isAuthenticatedCheck = state.auth.isAuthenticated;
　　　　const hasUserIdCheck = state.auth.userInfo && state.auth.userInfo.userid;
　　　　
　　　　console.log("🔍 认证条件检查:", {
　　　　　　isAuthenticatedCheck,
　　　　　　hasUserIdCheck,
　　　　　　bothConditions: isAuthenticatedCheck && hasUserIdCheck
　　　　});
　　　　
　　　　// 🎯 如果已经认证且有用户ID，直接返回成功
　　　　if (isAuthenticatedCheck && hasUserIdCheck) {
　　　　　　console.log("✅ 认证检查通过，用户已登录");
　　　　　　return { success: true, userInfo: state.auth.userInfo };
　　　　}
　　　　
　　　　console.log("❌ 认证检查失败，需要重新认证");
　　　　console.log("❌ 失败原因:", {
　　　　　　isAuthenticated: isAuthenticatedCheck ? "✅" : "❌ 未认证",
　　　　　　hasUserId: hasUserIdCheck ? "✅" : "❌ 无用户ID"
　　　　});
　　　　
　　　　// 保存当前页面路径，用于授权后跳转
　　　　const currentPath = getCurrentPagePath();
　　　　if (currentPath && currentPath !== '/pages/dtest/home') {
　　　　　　commit('SET_REDIRECT_PATH', currentPath);
　　　　　　console.log("🔗 保存重定向路径:", currentPath);
　　　　}
　　　　
　　　　// 跳转到home页面进行认证
　　　　console.log("🔄 跳转到认证页面");
　　　　setTimeout(() => {
　　　　　　uni.reLaunch({
　　　　　　　　url: '/pages/dtest/home'
　　　　　　});
　　　　}, 100);
　　　　
　　　　return { success: false, error: '需要认证' };
　　},
　　
　　// 🎯 直接认证检查（用于非主页页面，避免显示主页）
　　async checkAuthStatusDirect({ state, commit, dispatch }) {
　　　　console.log("🔍 直接认证检查 - 详细状态:", {
　　　　　　isAuthenticated: state.auth.isAuthenticated,
　　　　　　userid: state.auth.userInfo.userid,
　　　　　　empname: state.auth.userInfo.empname
　　　　});
　　　　
　　　　// 🎯 详细检查认证条件
　　　　const isAuthenticatedCheck = state.auth.isAuthenticated;
　　　　const hasUserIdCheck = state.auth.userInfo && state.auth.userInfo.userid;
　　　　
　　　　// 🎯 如果已经认证且有用户ID，直接返回成功
　　　　if (isAuthenticatedCheck && hasUserIdCheck) {
　　　　　　console.log("✅ 认证检查通过，用户已登录");
　　　　　　return { success: true, userInfo: state.auth.userInfo };
　　　　}
　　　　
　　　　console.log("❌ 认证检查失败，需要重新认证");
　　　　
　　　　// 保存当前页面路径，用于授权后跳转
　　　　const currentPath = getCurrentPagePath();
　　　　if (currentPath) {
　　　　　　commit('SET_REDIRECT_PATH', currentPath);
　　　　　　console.log("🔗 保存重定向路径:", currentPath);
　　　　}
　　　　
　　　　// 🔄 立即返回失败状态，然后异步处理跳转
　　　　console.log("🔄 立即返回认证失败，异步处理跳转");
　　　　
　　　　// 🎯 异步处理跳转，不阻塞返回
　　　　setTimeout(async () => {
　　　　　　try {
　　　　　　　　console.log("🔄 开始异步跳转到企业微信授权");
　　　　　　　　await dispatch('getAuthUrl');
　　　　　　} catch (error) {
　　　　　　　　console.error("❌ 获取授权URL失败:", error);
　　　　　　　　// 如果获取授权URL失败，还是跳转到主页
　　　　　　　　uni.reLaunch({
　　　　　　　　　　url: '/pages/dtest/home'
　　　　　　　　});
　　　　　　}
　　　　}, 100);
　　　　
　　　　// 🎯 立即返回失败，让页面保持loading状态
　　　　return { success: false, error: '需要认证' };
　　},
　　
　　// 🎯 处理授权成功后的跳转
　　handleAuthSuccess({ state, commit }) {
　　　　const redirectPath = state.auth.redirectPath;
　　　　console.log("🎯 检查重定向路径:", redirectPath);
　　　　
　　　　if (redirectPath && redirectPath !== '/pages/dtest/home') {
　　　　　　console.log("🎯 授权成功，立即跳转到原页面:", redirectPath);
　　　　　　
　　　　　　// 清除重定向路径
　　　　　　commit('SET_REDIRECT_PATH', '');
　　　　　　
　　　　　　// 🔧 立即跳转，最小延迟，避免显示主页
　　　　　　setTimeout(() => {
　　　　　　　　uni.reLaunch({
　　　　　　　　　　url: redirectPath
　　　　　　　　});
　　　　　　}, 50); // 最小延迟，几乎立即跳转
　　　　} else {
　　　　　　// 清除重定向路径
　　　　　　commit('SET_REDIRECT_PATH', '');
　　　　　　console.log("🏠 没有重定向路径，显示主页");
　　　　}
　　},
　　
　　async performAuth({ commit, state, getters }) {
　　　　// 🔒 防止重复执行认证
　　　　if (state.auth.isAuthLocked) {
　　　　　　console.log("🔒 认证正在进行中，跳过重复执行");
　　　　　　return;
　　　　}
　　　　
　　　　commit('SET_AUTH_LOCKED', true);
　　　　commit('SET_AUTH_AUTHENTICATING', true);
　　　　
　　　　try {
　　　　　　console.log("🔍 开始自动认证检查...");
　　　　　　
　　　　　　// 1. 检查本地登录状态和Vuex持久化状态
　　　　　　commit('SET_LOADING_MESSAGE', '正在检查登录状态...');
　　　　　　
　　　　　　// 首先检查Vuex持久化的状态
　　　　　　if (state.auth.isAuthenticated && state.auth.userInfo.userid) {
　　　　　　　　console.log("✅ 发现Vuex持久化的认证状态:", state.auth.userInfo);
　　　　　　　　console.log("📊 持久化用户数据详情:");
　　　　　　　　console.log("- userid:", state.auth.userInfo.userid);
　　　　　　　　console.log("- empname:", state.auth.userInfo.empname);
　　　　　　　　console.log("- orgname:", state.auth.userInfo.orgname);
　　　　　　　　console.log("- emptype:", state.auth.userInfo.emptype);
　　　　　　　　
　　　　　　　　commit('SET_LOADING_MESSAGE', '恢复登录状态中...');
　　　　　　　　
　　　　　　　　// 更新员工信息（确保UI显示数据完整）
　　　　　　　　await this.dispatch('updateEmployeeInfo', state.auth.userInfo);
　　　　　　　　
　　　　　　　　// 初始化企业微信JSSDK
　　　　　　　　console.log("🔧 恢复登录状态，开始初始化企业微信JSSDK...");
　　　　　　　　commit('SET_LOADING_MESSAGE', '正在初始化企业微信功能...');
　　　　　　　　await this.dispatch('initWxJSSDK');
　　　　　　　　
　　　　　　　　// 登录成功，显示主界面
　　　　　　　　this.dispatch('showMainContent');
　　　　　　　　return;
　　　　　　}
　　　　　　
　　　　　　// 检查localStorage中的用户信息（向后兼容）
　　　　　　const storedUserInfo = uni.getStorageSync('userInfo');
　　　　　　if (storedUserInfo && storedUserInfo.userid) {
　　　　　　　　console.log("✅ 发现本地存储的登录状态:", storedUserInfo);
　　　　　　　　commit('SET_LOADING_MESSAGE', '登录验证成功，正在初始化...');
　　　　　　　　
　　　　　　　　// 更新Vuex状态
　　　　　　　　commit('SET_USER_INFO', storedUserInfo);
　　　　　　　　await this.dispatch('updateEmployeeInfo', storedUserInfo);
　　　　　　　　commit('SET_AUTH_AUTHENTICATED', true);
　　　　　　　　
　　　　　　　　// 初始化企业微信JSSDK
　　　　　　　　console.log("🔧 已登录用户，开始初始化企业微信JSSDK...");
　　　　　　　　commit('SET_LOADING_MESSAGE', '正在初始化企业微信功能...');
　　　　　　　　await this.dispatch('initWxJSSDK');
　　　　　　　　
　　　　　　　　// 登录成功，显示主界面
　　　　　　　　this.dispatch('showMainContent');
　　　　　　　　return;
　　　　　　}
　　　　　　
　　　　　　// 2. 检查URL中的code参数
　　　　　　const urlParams = new URLSearchParams(window.location.search);
　　　　　　const code = urlParams.get('code');
　　　　　　
　　　　　　console.log("🔍 检查URL参数:");
　　　　　　console.log("- search:", window.location.search);
　　　　　　console.log("- hash:", window.location.hash);
　　　　　　console.log("- code:", code);
　　　　　　
　　　　　　if (code) {
　　　　　　　　console.log("🔐 发现授权码，开始登录验证:", code);
　　　　　　　　commit('SET_LOADING_MESSAGE', '正在验证企业微信授权...');
　　　　　　　　
　　　　　　　　// 调用后端login接口验证
　　　　　　　　await this.dispatch('loginWithCode', code);
　　　　　　} else {
　　　　　　　　console.log("🔗 没有授权码，自动跳转到企业微信授权");
　　　　　　　　commit('SET_LOADING_MESSAGE', '正在跳转到企业微信授权...');
　　　　　　　　await this.dispatch('getAuthUrl');
　　　　　　}
　　　　　　
　　　　} catch (error) {
　　　　　　console.error("❌ 认证失败:", error);
　　　　　　this.dispatch('handleAuthError', '认证过程出现错误，请重试');
　　　　} finally {
　　　　　　// 🔓 无论成功失败，都要释放锁
　　　　　　commit('SET_AUTH_LOCKED', false);
　　　　}
　　},
　　
　　async loginWithCode({ commit, getters }, code) {
　　　　try {
　　　　　　commit('SET_LOADING_MESSAGE', '正在验证登录信息...');
　　　　　　
			const loginUrl = `${getters.getApiUrl('v2')}/login?code=${code}&state=STATE`;
　　　　　　
　　　　　　console.log("📤 发送登录请求:");
　　　　　　console.log("- URL:", loginUrl);
　　　　　　console.log("- Code:", code);
　　　　　　
　　　　　　const response = await uni.request({
　　　　　　　　url: loginUrl,
　　　　　　　　method: 'GET'
　　　　　　});
　　　　　　
　　　　　　console.log("📥 登录响应:", response.data);
　　　　　　
　　　　　　console.log("📥 完整的登录响应:", response);
　　　　　　
　　　　　　if (response.data && response.data.status === 1) {
　　　　　　　　// ✅ 登录成功
　　　　　　　　const userInfo = response.data.data;
　　　　　　　　console.log("✅ 登录成功，用户数据:", userInfo);
　　　　　　　　console.log("📊 用户数据详情:");
　　　　　　　　console.log("- userid:", userInfo.userid);
　　　　　　　　console.log("- empname:", userInfo.empname);
　　　　　　　　console.log("- emptype:", userInfo.emptype);
　　　　　　　　console.log("- orgname:", userInfo.orgname);
　　　　　　　　console.log("- cardid:", userInfo.cardid);
　　　　　　　　console.log("- telephone:", userInfo.telephone);
　　　　　　　　console.log("- startdate:", userInfo.startdate);
　　　　　　　　
　　　　　　　　commit('SET_LOADING_MESSAGE', '登录成功，正在保存用户信息...');
　　　　　　　　
　　　　　　　　// 🔧 重要：先保存到Vuex状态
　　　　　　　　commit('SET_USER_INFO', userInfo);
　　　　　　　　commit('SET_AUTH_AUTHENTICATED', true);
　　　　　　　　
　　　　　　　　// 🔧 同时保存到localStorage作为备份
　　　　　　　　uni.setStorageSync('userInfo', userInfo);
　　　　　　　　console.log("💾 用户信息已保存到localStorage");
　　　　　　　　
　　　　　　　　// 🔧 更新员工详细信息
　　　　　　　　await this.dispatch('updateEmployeeInfo', userInfo);
　　　　　　　　console.log("👤 员工信息已更新");
　　　　　　　　
　　　　　　　　// 清理URL参数
　　　　　　　　this.dispatch('cleanUrlParams');
　　　　　　　　
　　　　　　　　// 初始化企业微信JSSDK
　　　　　　　　console.log("🔧 登录成功，开始初始化企业微信JSSDK...");
　　　　　　　　commit('SET_LOADING_MESSAGE', '正在初始化企业微信功能...');
　　　　　　　　await this.dispatch('initWxJSSDK');
　　　　　　　　
　　　　　　　　// 显示主界面
　　　　　　　　this.dispatch('showMainContent');
　　　　　　　　
　　　　　　} else {
　　　　　　　　// ❌ 登录失败 - 跳转到无权限页面
　　　　　　　　const errorMsg = response.data?.message || '登录验证失败';
　　　　　　　　console.error("❌ 登录失败:", response.data);
　　　　　　　　this.dispatch('handleAuthError', errorMsg);
　　　　　　}
　　　　　　
　　　　} catch (error) {
　　　　　　console.error("❌ 登录请求失败:", error);
　　　　　　this.dispatch('handleAuthError', '网络连接失败，请检查网络后重试');
　　　　}
　　},
　　
　　async getAuthUrl({ commit, getters, state }, options = {}) {
　　　　try {
　　　　　　commit('SET_LOADING_MESSAGE', '正在获取授权链接...');
　　　　　　
　　　　　　// 🎯 如果传入了redirectPath，保存到状态中
　　　　　　if (options.redirectPath) {
　　　　　　　　commit('SET_REDIRECT_PATH', options.redirectPath);
　　　　　　　　console.log("🔗 保存重定向路径:", options.redirectPath);
　　　　　　}
　　　　　　
		const urlEndpoint = `${getters.getApiUrl('v2')}/url`;
　　　　　　
　　　　　　console.log("📤 获取授权URL:", urlEndpoint);
　　　　　　
　　　　　　const response = await uni.request({
　　　　　　　　url: urlEndpoint,
　　　　　　　　method: 'GET'
　　　　　　});
　　　　　　
　　　　　　console.log("📥 授权URL响应:", response.data);
　　　　　　
　　　　　　if (response.data && response.data.status === 1) {
　　　　　　　　const authUrl = response.data.data.auth_url;
　　　　　　　　console.log("🔗 获取到授权URL:", authUrl);
　　　　　　　　
　　　　　　　　// 🎯 如果调用者需要返回URL（如重新登录功能），则返回URL
　　　　　　　　if (options.returnUrl) {
　　　　　　　　　　console.log("✅ 返回授权URL供调用者使用");
　　　　　　　　　　return authUrl;
　　　　　　　　}
　　　　　　　　
　　　　　　　　// 🎯 否则直接跳转（原有逻辑）
　　　　　　　　commit('SET_LOADING_MESSAGE', '正在跳转到企业微信授权...');
　　　　　　　　
　　　　　　　　// 延迟一下让用户看到提示信息
　　　　　　　　setTimeout(() => {
　　　　　　　　　　window.location.href = authUrl;
　　　　　　　　}, 1000);
　　　　　　　　
　　　　　　　　return authUrl; // 也返回URL，方便调用者使用
　　　　　　　　
　　　　　　} else {
　　　　　　　　throw new Error(response.data?.message || '获取授权URL失败');
　　　　　　}
　　　　　　
　　　　} catch (error) {
　　　　　　console.error("❌ 获取授权URL失败:", error);
　　　　　　// 🎯 如果是重新登录调用，抛出错误让调用者处理
　　　　　　if (options.returnUrl) {
　　　　　　　　throw error;
　　　　　　}
　　　　　　this.dispatch('handleAuthError', '获取授权链接失败，请重试');
　　　　　　throw error;
　　　　}
　　},
　　
　　cleanUrlParams() {
　　　　if (window.history && window.history.replaceState) {
　　　　　　const url = new URL(window.location);
　　　　　　url.searchParams.delete('code');
　　　　　　url.searchParams.delete('state');
　　　　　　window.history.replaceState({}, document.title, url.toString());
　　　　　　console.log("🧹 已清理URL参数");
　　　　}
　　},
　　
　　showMainContent({ commit, dispatch }) {
　　　　console.log("✅ 认证完成，显示主界面");
　　　　commit('SET_AUTH_AUTHENTICATING', false);
　　　　commit('SET_AUTH_AUTHENTICATED', true);
　　　　commit('SET_AUTH_LOCKED', false); // 🔓 释放认证锁
　　　　commit('SET_LOADING_MESSAGE', ''); // 清空加载消息
　　　　
　　　　// 🎯 检查是否需要跳转到其他页面
　　　　dispatch('handleAuthSuccess');
　　},
　　
　　handleAuthError({ commit }, errorMessage) {
　　　　console.error("❌ 认证失败，跳转到无权限页面:", errorMessage);
　　　　
　　　　// 🔓 释放认证锁
　　　　commit('SET_AUTH_LOCKED', false);
　　　　commit('SET_AUTH_ERROR', errorMessage);
　　　　
　　　　// 跳转到无权限页面
　　　　uni.redirectTo({
　　　　　　url: '/pages/index/not?error=' + encodeURIComponent(errorMessage)
　　　　});
　　},
　　
　　updateEmployeeInfo({ commit }, userInfo) {
　　　　console.log("🔧 更新员工信息:", userInfo);
　　　　
　　　　// 获取岗位类型对应的精美图标
　　　　const getEmpTypeIcon = (emptype) => {
　　　　　　const empTypeStr = (emptype || '').toLowerCase();
　　　　　　console.log("🔍 匹配岗位类型:", empTypeStr);
　　　　　　
　　　　　　if (empTypeStr.includes('设计师') || empTypeStr.includes('设计') || empTypeStr.includes('美工') || 
　　　　　　　　empTypeStr.includes('ui') || empTypeStr.includes('ux') || empTypeStr.includes('平面') || 
　　　　　　　　empTypeStr.includes('视觉') || empTypeStr.includes('创意')) {
　　　　　　　　return 'brush-fill';
　　　　　　}
　　　　　　else if (empTypeStr.includes('工程师') || empTypeStr.includes('开发') || empTypeStr.includes('技术') || 
　　　　　　　　empTypeStr.includes('程序员') || empTypeStr.includes('软件') || empTypeStr.includes('系统') ||
　　　　　　　　empTypeStr.includes('架构师') || empTypeStr.includes('算法') || empTypeStr.includes('数据') ||
　　　　　　　　empTypeStr.includes('前端') || empTypeStr.includes('后端') || empTypeStr.includes('全栈') ||
　　　　　　　　empTypeStr.includes('测试') || empTypeStr.includes('运维') || empTypeStr.includes('devops')) {
　　　　　　　　return 'laptop-fill';
　　　　　　}
　　　　　　else if (empTypeStr.includes('业务员') || empTypeStr.includes('业务专员') || empTypeStr.includes('业务') || 
　　　　　　　　　empTypeStr.includes('销售') || empTypeStr.includes('营销') || empTypeStr.includes('市场') ||
　　　　　　　　　empTypeStr.includes('商务') || empTypeStr.includes('拓展') || empTypeStr.includes('推广') ||
　　　　　　　　　empTypeStr.includes('客户经理') || empTypeStr.includes('销售代表')) {
　　　　　　　　return 'people-circle-fill';
　　　　　　}
　　　　　　else if (empTypeStr.includes('管理') || empTypeStr.includes('主管') || empTypeStr.includes('经理') || 
　　　　　　　　　empTypeStr.includes('总监') || empTypeStr.includes('主任') || empTypeStr.includes('负责人') ||
　　　　　　　　　empTypeStr.includes('总经理') || empTypeStr.includes('副总') || empTypeStr.includes('部长') ||
　　　　　　　　　empTypeStr.includes('科长') || empTypeStr.includes('组长') || empTypeStr.includes('队长')) {
　　　　　　　　return 'people-fill';
　　　　　　}
　　　　　　else if (empTypeStr.includes('司机') || empTypeStr.includes('驾驶') || empTypeStr.includes('驾驶员') || 
　　　　　　　　　empTypeStr.includes('车辆') || empTypeStr.includes('运输') || empTypeStr.includes('配送员') ||
　　　　　　　　　empTypeStr.includes('送货') || empTypeStr.includes('快递')) {
　　　　　　　　return 'car-fill';
　　　　　　}
　　　　　　else {
　　　　　　　　return 'briefcase-fill';
　　　　　　}
　　　　};
　　　　
　　　　const selectedIcon = getEmpTypeIcon(userInfo.emptype);
　　　　console.log("🎨 选择的岗位图标:", selectedIcon);
　　　　
　　　　const employeeInfo = {
　　　　　　name: userInfo.empname || userInfo.nickname || '未知用户',
　　　　　　nameInitial: ((userInfo.empname || userInfo.nickname || '未').charAt(0)),
　　　　　　title: userInfo.emptype || '未知岗位',
　　　　　　id: userInfo.cardid || userInfo.userid || '未知',
　　　　　　department: userInfo.orgname || '未知部门',
　　　　　　isactive: userInfo.isactive || '1', // 🎯 在职状态
　　　　　　startdate: userInfo.startdate || '未知',
　　　　　　telephone: userInfo.telephone || '' // 🎯 电话号码
　　　　};
　　　　
　　　　commit('SET_EMPLOYEE_INFO', employeeInfo);
　　　　console.log("✅ 员工信息更新完成:", employeeInfo);
　　},
　　
　　async initWxJSSDK({ commit, getters }) {
　　　　try {
　　　　　　console.log('🔧 开始初始化企业微信JSSDK...');
　　　　　　
　　　　　　// 动态导入企业微信JSSDK
　　　　　　const ww = await import('@wecom/jssdk');
　　　　　　
　　　　　　// 注册企业微信JSSDK
　　　　　　ww.register({
　　　　　　　　corpId: 'ww44da95994e8f32c1',
　　　　　　　　jsApiList: ['scanQRCode'],
　　　　　　　　getConfigSignature: async (url) => {
　　　　　　　　　　// 请求后端API获取签名
　　　　　　　　　　return new Promise((resolve, reject) => {
　　　　　　　　　　　　const targetUrl = encodeURIComponent(url || window.location.href);
　　　　　　　　　　　　const baseUrl = getters.currentApiBaseUrl;
　　　　　　　　　　　　const apiUrl = `${getters.getApiUrl('v1')}/Building?url=${targetUrl}`;
　　　　　　　　　　　　
　　　　　　　　　　　　console.log('🔧 请求签名接口:', apiUrl);
　　　　　　　　　　　　
　　　　　　　　　　　　uni.request({
　　　　　　　　　　　　　　url: apiUrl,
　　　　　　　　　　　　　　success: (res) => {
　　　　　　　　　　　　　　　　if (res.statusCode === 200 && res.data) {
　　　　　　　　　　　　　　　　　　resolve({
　　　　　　　　　　　　　　　　　　　　timestamp: res.data.timestamp,
　　　　　　　　　　　　　　　　　　　　nonceStr: res.data.nonceStr,
　　　　　　　　　　　　　　　　　　　　signature: res.data.signature
　　　　　　　　　　　　　　　　　　});
　　　　　　　　　　　　　　　　} else {
　　　　　　　　　　　　　　　　　　reject(new Error('获取签名失败'));
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　},
　　　　　　　　　　　　　　fail: (err) => {
　　　　　　　　　　　　　　　　reject(err);
　　　　　　　　　　　　　　}
　　　　　　　　　　　　});
　　　　　　　　　　});
　　　　　　　　}
　　　　　　});
　　　　　　
　　　　　　console.log('✅ 企业微信JSSDK注册成功');
　　　　　　commit('SET_WX_JSSDK_READY', true);
　　　　　　
　　　　　　// 等待一小段时间确保JSSDK完全初始化
　　　　　　await new Promise(resolve => setTimeout(resolve, 500));
　　　　　　
　　　　} catch (error) {
　　　　　　console.error('❌ 企业微信JSSDK注册失败:', error);
　　　　　　commit('SET_WX_JSSDK_READY', false);
　　　　}
　　},
　　
　　logout({ commit }) {
　　　　console.log('🔐 用户登出');
　　　　
　　　　// 清除本地存储
　　　　uni.removeStorageSync('userInfo');
　　　　
　　　　// 清除状态
　　　　commit('CLEAR_AUTH_STATE');
　　　　
　　　　// 跳转到首页重新认证
　　　　uni.reLaunch({
　　　　　　url: '/pages/dtest/home'
　　　　});
　　}
 },
 plugins: [createPersistedState({
 　　storage: window.sessionStorage,
 　　reducer(val)  {
         // 🔧 持久化状态管理 - 只保存需要持久化的数据
         console.log("💾 持久化状态:", {
             auth: val.auth,
             userInfo: val.auth?.userInfo,
             isAuthenticated: val.auth?.isAuthenticated
         });
         
         return {
             count: val.count,
             isDevelopment: val.isDevelopment,
             apiBaseUrl: val.apiBaseUrl,
             apiBaseUrlProduction: val.apiBaseUrlProduction,
             apiVersion: val.apiVersion,
             apiVersionV1: val.apiVersionV1,
             // 🔐 持久化认证状态（重要数据）
             auth: {
                 isAuthenticated: val.auth.isAuthenticated,
                 userInfo: val.auth.userInfo,
                 employeeInfo: val.auth.employeeInfo,
                 wxJSSDKReady: val.auth.wxJSSDKReady,
                 redirectPath: val.auth.redirectPath, // 🎯 持久化重定向路径
                 // 🔧 重置临时状态
                 isAuthenticating: false,
                 isAuthLocked: false,
                 loadingMessage: '',
                 authError: null
             }
         }
     }
 })]
})

export default store